{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Logistic Regression with a Neural Network mindset\n",
    "\n",
    "欢迎来到您的第一个（必填）编程任务！你将建立一个逻辑回归分类器来识别猫。这个任务将指导你如何用神经网络的思维方式做到这一点，所以也将磨练你对深度学习的直觉。\n",
    "\n",
    "**说明：**\n",
    "\n",
    "不要在代码中使用循环（for / while），除非指令明确要求您这样做。\n",
    "\n",
    "**您将学习：**\n",
    "\n",
    "构建一个学习算法的总体架构，包括：\n",
    "- 初始化参数\n",
    "- 计算成本函数及其梯度\n",
    "- 使用优化算法（梯度下降）\n",
    "将上述三个函数按照正确的顺序收集到主模型函数中。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 - Packages ##\n",
    "\n",
    "首先，运行下面的单元格，导入您在此作业中需要的所有软件包。\n",
    "- [numpy](www.numpy.org) 科学计算的基本软件包。\n",
    "- [h5py](http://www.h5py.org) 是与数据集（存储在H5文件中的数据集）交互的常用软件包。\n",
    "- [matplotlib](http://matplotlib.org) 著名的绘图工具\n",
    "- [PIL](http://www.pythonware.com/products/pil/) and [scipy](https://www.scipy.org/) 最后环节用自己的图片测试自己的模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import h5py\n",
    "import scipy\n",
    "from PIL import Image\n",
    "from scipy import ndimage\n",
    "from lr_utils import load_dataset\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 2 - Overview of the Problem set ##\n",
    "\n",
    "**Problem Statement**: 给你一个数据集 (\"data.h5\") ，它包含以下信息:\n",
    "    - a training set of m_train images labeled as cat (y=1) or non-cat (y=0)\n",
    "    - a test set of m_test images labeled as cat or non-cat\n",
    "    - each image is of shape (num_px, num_px, 3) where 3 is for the 3 channels (RGB). Thus, each image is square (height = num_px) and (width = num_px).\n",
    "\n",
    "您将构建一个简单的图像识别算法，可以正确地将图片分类为猫或非猫\n",
    "\n",
    "现在来熟悉下数据集。运行下面的代码加载数据。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Loading the data (cat/non-cat)\n",
    "train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们在图像数据集（训练和测试）的最后添加了“_orig”，因为我们要对它们进行预处理。 After preprocessing, we will end up with train_set_x and test_set_x (train_set_y和test_set_y标签不需要任何预处理).\n",
    "\n",
    "train_set_x_orig和test_set_x_orig的每一行都是一个表示图像的数组。您可以通过运行以下代码来可视化示例。随意更改index值并重新运行以查看其他图像。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = [0], it's a 'non-cat' picture.\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP4AAAD8CAYAAABXXhlaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x240ed490e80>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Example of a picture\n",
    "index = 5\n",
    "plt.imshow(train_set_x_orig[index])\n",
    "print (\"y = \" + str(train_set_y[:, index]) + \", it's a '\" + classes[np.squeeze(train_set_y[:, index])].decode(\"utf-8\") +  \"' picture.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "深度学习中的很多software bugs都是因为矩阵/矢量的维度不匹配。如果你能保证矩阵/向量维度的正确，可以消除许多错误\n",
    "\n",
    "**Exercise:** Find the values for:\n",
    "    - m_train (number of training examples)\n",
    "    - m_test (number of test examples)\n",
    "    - num_px (= height = width of a training image)\n",
    "Remember that `train_set_x_orig` is a numpy-array of shape (m_train, num_px, num_px, 3). For instance, you can access `m_train` by writing `train_set_x_orig.shape[0]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of training examples: m_train = 209\n",
      "Number of testing examples: m_test = 50\n",
      "Height/Width of each image: num_px = 64\n",
      "Each image is of size: (64, 64, 3)\n",
      "train_set_x shape: (209, 64, 64, 3)\n",
      "train_set_y shape: (1, 209)\n",
      "test_set_x shape: (50, 64, 64, 3)\n",
      "test_set_y shape: (1, 50)\n"
     ]
    }
   ],
   "source": [
    "### START CODE HERE ### (≈ 3 lines of code)\n",
    "m_train = train_set_x_orig.shape[0]\n",
    "m_test = test_set_x_orig.shape[0]\n",
    "num_px = train_set_x_orig.shape[1]\n",
    "### END CODE HERE ###\n",
    "\n",
    "print (\"Number of training examples: m_train = \" + str(m_train))\n",
    "print (\"Number of testing examples: m_test = \" + str(m_test))\n",
    "print (\"Height/Width of each image: num_px = \" + str(num_px))\n",
    "print (\"Each image is of size: (\" + str(num_px) + \", \" + str(num_px) + \", 3)\")\n",
    "print (\"train_set_x shape: \" + str(train_set_x_orig.shape))\n",
    "print (\"train_set_y shape: \" + str(train_set_y.shape))\n",
    "print (\"test_set_x shape: \" + str(test_set_x_orig.shape))\n",
    "print (\"test_set_y shape: \" + str(test_set_y.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output for m_train, m_test and num_px**: \n",
    "<table style=\"width:15%\">\n",
    "  <tr>\n",
    "    <td>**m_train**</td>\n",
    "    <td> 209 </td> \n",
    "  </tr>\n",
    "  \n",
    "  <tr>\n",
    "    <td>**m_test**</td>\n",
    "    <td> 50 </td> \n",
    "  </tr>\n",
    "  \n",
    "  <tr>\n",
    "    <td>**num_px**</td>\n",
    "    <td> 64 </td> \n",
    "  </tr>\n",
    "  \n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For convenience（方便起见）, you should now reshape images of shape (num_px, num_px, 3) in a numpy-array of shape (num_px $*$ num_px $*$ 3, 1). After this, our training (and test) dataset is a numpy-array where each column represents a flattened image. There should be m_train (respectively m_test) columns.\n",
    "\n",
    "**Exercise:** Reshape the training and test data sets so that images of size (num_px, num_px, 3) are flattened into single vectors of shape (num\\_px $*$ num\\_px $*$ 3, 1).\n",
    "\n",
    "A trick when you want to flatten a matrix X of shape (a,b,c,d) to a matrix X_flatten of shape (b$*$c$*$d, a) is to use: \n",
    "```python\n",
    "X_flatten = X.reshape(X.shape[0], -1).T      # X.T is the transpose of X\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_set_x_flatten shape: (12288, 209)\n",
      "train_set_y shape: (1, 209)\n",
      "test_set_x_flatten shape: (12288, 50)\n",
      "test_set_y shape: (1, 50)\n",
      "sanity check after reshaping: [17 31 56 22 33]\n"
     ]
    }
   ],
   "source": [
    "# Reshape the training and test examples\n",
    "\n",
    "### START CODE HERE ### (≈ 2 lines of code)\n",
    "train_set_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0], -1).T\n",
    "test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T\n",
    "### END CODE HERE ###\n",
    "\n",
    "print (\"train_set_x_flatten shape: \" + str(train_set_x_flatten.shape))\n",
    "print (\"train_set_y shape: \" + str(train_set_y.shape))\n",
    "print (\"test_set_x_flatten shape: \" + str(test_set_x_flatten.shape))\n",
    "print (\"test_set_y shape: \" + str(test_set_y.shape))\n",
    "print (\"sanity check after reshaping: \" + str(train_set_x_flatten[0:5,0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table style=\"width:35%\">\n",
    "  <tr>\n",
    "    <td>**train_set_x_flatten shape**</td>\n",
    "    <td> (12288, 209)</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>**train_set_y shape**</td>\n",
    "    <td>(1, 209)</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>**test_set_x_flatten shape**</td>\n",
    "    <td>(12288, 50)</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>**test_set_y shape**</td>\n",
    "    <td>(1, 50)</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "  <td>**sanity check after reshaping**</td>\n",
    "  <td>[17 31 56 22 33]</td> \n",
    "  </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了表示彩色图像，必须为每个像素指定红色，绿色和蓝色通道（RGB），因此像素值实际上是从0到255的三个数字的向量。\n",
    "\n",
    "机器学习中一个常见的预处理步骤是对数据集进行中心化和标准化，这意味着您从每个示例中减去整个numpy数组的平均值，然后将每个示例除以整个numpy数组的标准偏差。但是对于图片数据集来说，它更简单，更方便，几乎可以将数据集的每一行除以255（像素通道的最大值）。\n",
    "\n",
    "让我们标准化我们的数据集。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "train_set_x = train_set_x_flatten/255.\n",
    "test_set_x = test_set_x_flatten/255."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='blue'>\n",
    "**你需要记住的是：**\n",
    "\n",
    "面对一个新的数据集，常见的预处理步骤如下：\n",
    "- Figure out the dimensions and shapes of the problem (m_train, m_test, num_px, ...)\n",
    "- Reshape the datasets such that each example is now a vector of size (num_px \\* num_px \\* 3, 1)\n",
    "- \"Standardize\" the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 - General Architecture of the learning algorithm ##\n",
    "\n",
    "是时候设计一个简单的算法来区分猫图像和非猫图像。\n",
    "你将建立一个Logistic回归，使用神经网络的思维方式。下图解释了为什么**Logistic回归实际上是一个非常简单的神经网络！**\n",
    "\n",
    "<img src=\"images/LogReg_kiank.png\" style=\"width:650px;height:400px;\">\n",
    "\n",
    "**Mathematical expression of the algorithm**:\n",
    "\n",
    "For one example $x^{(i)}$:\n",
    "$$z^{(i)} = w^T x^{(i)} + b \\tag{1}$$\n",
    "$$\\hat{y}^{(i)} = a^{(i)} = sigmoid(z^{(i)})\\tag{2}$$ \n",
    "$$ \\mathcal{L}(a^{(i)}, y^{(i)}) =  - y^{(i)}  \\log(a^{(i)}) - (1-y^{(i)} )  \\log(1-a^{(i)})\\tag{3}$$\n",
    "\n",
    "The cost is then computed by summing over all training examples:\n",
    "$$ J = \\frac{1}{m} \\sum_{i=1}^m \\mathcal{L}(a^{(i)}, y^{(i)})\\tag{6}$$\n",
    "\n",
    "**关键步骤**：在本练习中，您将执行以下步骤：\n",
    "    - Initialize the parameters of the model\n",
    "    - Learn the parameters for the model by minimizing the cost  \n",
    "    - Use the learned parameters to make predictions (on the test set)\n",
    "    - Analyse the results and conclude"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 - Building the parts of our algorithm ## \n",
    "\n",
    "建立神经网络的主要步骤是：\n",
    "\n",
    "- 定义模型结构（如输入特征的个数）\n",
    "- 初始化模型的参数\n",
    "- 循环：\n",
    " - 计算当前损失（正向传播）\n",
    " - 计算当前梯度（反向传播）\n",
    " - 更新参数（梯度下降）\n",
    " \n",
    "你经常分别建立1-3，并把它们整合到我们所说的一个函数中model()。\n",
    "\n",
    "### 4.1 - Helper functions 辅助函数\n",
    "\n",
    "**Exercise**: Using your code from \"Python Basics\", implement `sigmoid()`. As you've seen in the figure above, you need to compute $sigmoid( w^T x + b) = \\frac{1}{1 + e^{-(w^T x + b)}}$ to make predictions. Use np.exp()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: sigmoid\n",
    "\n",
    "def sigmoid(z):\n",
    "    \"\"\"\n",
    "    Compute the sigmoid of z\n",
    "\n",
    "    Arguments:\n",
    "    z -- A scalar or numpy array of any size.\n",
    "\n",
    "    Return:\n",
    "    s -- sigmoid(z)\n",
    "    \"\"\"\n",
    "\n",
    "    ### START CODE HERE ### (≈ 1 line of code)\n",
    "    s = 1 / (1 + np.exp(-z))\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sigmoid([0, 2]) = [ 0.5         0.88079708]\n"
     ]
    }
   ],
   "source": [
    "print (\"sigmoid([0, 2]) = \" + str(sigmoid(np.array([0,2]))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table>\n",
    "  <tr>\n",
    "    <td>**sigmoid([0, 2])**</td>\n",
    "    <td> [ 0.5         0.88079708]</td> \n",
    "  </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 - Initializing parameters\n",
    "\n",
    "**Exercise:** 在下面的单元格中实现参数初始化。您必须将w初始化为零向量。如果您不知道要使用哪个numpy函数，请在Numpy库文档中查找 np.zeros()。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: initialize_with_zeros\n",
    "\n",
    "def initialize_with_zeros(dim):\n",
    "    \"\"\"\n",
    "    This function creates a vector of zeros of shape (dim, 1) for w and initializes b to 0.\n",
    "    \n",
    "    Argument:\n",
    "    dim -- size of the w vector we want (or number of parameters in this case)\n",
    "    \n",
    "    Returns:\n",
    "    w -- initialized vector of shape (dim, 1)\n",
    "    b -- initialized scalar (corresponds to the bias)\n",
    "    \"\"\"\n",
    "    \n",
    "    ### START CODE HERE ### (≈ 1 line of code)\n",
    "    w = np.zeros((dim, 1))\n",
    "    b = 0\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    assert(w.shape == (dim, 1))\n",
    "    assert(isinstance(b, float) or isinstance(b, int))\n",
    "    \n",
    "    return w, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w = [[ 0.]\n",
      " [ 0.]]\n",
      "b = 0\n"
     ]
    }
   ],
   "source": [
    "dim = 2\n",
    "w, b = initialize_with_zeros(dim)\n",
    "print (\"w = \" + str(w))\n",
    "print (\"b = \" + str(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "\n",
    "<table style=\"width:15%\">\n",
    "    <tr>\n",
    "        <td>  ** w **  </td>\n",
    "        <td> [[ 0.]\n",
    " [ 0.]] </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>  ** b **  </td>\n",
    "        <td> 0 </td>\n",
    "    </tr>\n",
    "</table>\n",
    "\n",
    "For image inputs, w will be of shape (num_px $\\times$ num_px $\\times$ 3, 1)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3 - Forward and Backward propagation\n",
    "\n",
    "现在您的参数已初始化，您可以执行“前向”和“后向”传播来学习参数。\n",
    "\n",
    "**Exercise:** Implement a function `propagate()` that computes the cost function and its gradient.\n",
    "\n",
    "**Hints**:\n",
    "\n",
    "Forward Propagation:\n",
    "- You get X\n",
    "- You compute $A = \\sigma(w^T X + b) = (a^{(0)}, a^{(1)}, ..., a^{(m-1)}, a^{(m)})$\n",
    "- You calculate the cost function: $J = -\\frac{1}{m}\\sum_{i=1}^{m}y^{(i)}\\log(a^{(i)})+(1-y^{(i)})\\log(1-a^{(i)})$\n",
    "\n",
    "Here are the two formulas you will be using: \n",
    "\n",
    "$$ \\frac{\\partial J}{\\partial w} = \\frac{1}{m}X(A-Y)^T\\tag{7}$$\n",
    "$$ \\frac{\\partial J}{\\partial b} = \\frac{1}{m} \\sum_{i=1}^m (a^{(i)}-y^{(i)})\\tag{8}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: propagate\n",
    "\n",
    "def propagate(w, b, X, Y):\n",
    "    \"\"\"\n",
    "    Implement the cost function and its gradient for the propagation explained above\n",
    "\n",
    "    Arguments:\n",
    "    w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n",
    "    b -- bias, a scalar\n",
    "    X -- data of size (num_px * num_px * 3, number of examples)\n",
    "    Y -- true \"label\" vector (containing 0 if non-cat, 1 if cat) of size (1, number of examples)\n",
    "\n",
    "    Return:\n",
    "    cost -- negative log-likelihood cost for logistic regression\n",
    "    dw -- gradient of the loss with respect to w, thus same shape as w\n",
    "    db -- gradient of the loss with respect to b, thus same shape as b\n",
    "    \n",
    "    Tips:\n",
    "    - Write your code step by step for the propagation. np.log(), np.dot()\n",
    "    \"\"\"\n",
    "    \n",
    "    m = X.shape[1]\n",
    "    \n",
    "    # FORWARD PROPAGATION (FROM X TO COST)\n",
    "    ### START CODE HERE ### (≈ 2 lines of code)\n",
    "    A = sigmoid(np.dot(w.T, X) + b)            # compute activation\n",
    "    cost = -1 / m * np.sum(Y * np.log(A) + (1 - Y) * np.log(1 - A))         # compute cost\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # BACKWARD PROPAGATION (TO FIND GRAD)\n",
    "    ### START CODE HERE ### (≈ 2 lines of code)\n",
    "    dw = 1 / m * np.dot(X, (A - Y).T)\n",
    "    db = 1 / m * np.sum(A - Y)\n",
    "    ### END CODE HERE ###\n",
    "    assert(dw.shape == w.shape)\n",
    "    assert(db.dtype == float)\n",
    "    cost = np.squeeze(cost)\n",
    "    assert(cost.shape == ())\n",
    "    \n",
    "    grads = {\"dw\": dw,\n",
    "             \"db\": db}\n",
    "    \n",
    "    return grads, cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dw = [[ 0.99993216]\n",
      " [ 1.99980262]]\n",
      "db = 0.499935230625\n",
      "cost = 6.00006477319\n"
     ]
    }
   ],
   "source": [
    "w, b, X, Y = np.array([[1],[2]]), 2, np.array([[1,2],[3,4]]), np.array([[1,0]])\n",
    "grads, cost = propagate(w, b, X, Y)\n",
    "print (\"dw = \" + str(grads[\"dw\"]))\n",
    "print (\"db = \" + str(grads[\"db\"]))\n",
    "print (\"cost = \" + str(cost))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**:\n",
    "\n",
    "<table style=\"width:50%\">\n",
    "    <tr>\n",
    "        <td>  ** dw **  </td>\n",
    "        <td> [[ 0.99993216]\n",
    " [ 1.99980262]]</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>  ** db **  </td>\n",
    "        <td> 0.499935230625 </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>  ** cost **  </td>\n",
    "        <td> 6.000064773192205</td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### d) Optimization\n",
    "- 你已经初始化了你的参数。\n",
    "- 您也可以计算成本函数及其梯度。\n",
    "- 现在，您要使用梯度下降来更新参数。\n",
    "\n",
    "**Exercise:** Write down the optimization function. The goal is to learn $w$ and $b$ by minimizing the cost function $J$. For a parameter $\\theta$, the update rule is $ \\theta = \\theta - \\alpha \\text{ } d\\theta$, where $\\alpha$ is the learning rate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: optimize\n",
    "\n",
    "def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):\n",
    "    \"\"\"\n",
    "    This function optimizes w and b by running a gradient descent algorithm\n",
    "    \n",
    "    Arguments:\n",
    "    w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n",
    "    b -- bias, a scalar\n",
    "    X -- data of shape (num_px * num_px * 3, number of examples)\n",
    "    Y -- true \"label\" vector (containing 0 if non-cat, 1 if cat), of shape (1, number of examples)\n",
    "    num_iterations -- number of iterations of the optimization loop\n",
    "    learning_rate -- learning rate of the gradient descent update rule\n",
    "    print_cost -- True to print the loss every 100 steps\n",
    "    \n",
    "    Returns:\n",
    "    params -- dictionary containing the weights w and bias b\n",
    "    grads -- dictionary containing the gradients of the weights and bias with respect to the cost function\n",
    "    costs -- list of all the costs computed during the optimization, this will be used to plot the learning curve.\n",
    "    \n",
    "    Tips:\n",
    "    You basically need to write down two steps and iterate through them:\n",
    "        1) Calculate the cost and the gradient for the current parameters. Use propagate().\n",
    "        2) Update the parameters using gradient descent rule for w and b.\n",
    "    \"\"\"\n",
    "    \n",
    "    costs = []\n",
    "    \n",
    "    for i in range(num_iterations):\n",
    "        \n",
    "        \n",
    "        # Cost and gradient calculation (≈ 1-4 lines of code)\n",
    "        ### START CODE HERE ### \n",
    "        grads, cost = propagate(w, b, X, Y)\n",
    "        ### END CODE HERE ###\n",
    "        \n",
    "        # Retrieve derivatives from grads\n",
    "        dw = grads[\"dw\"]\n",
    "        db = grads[\"db\"]\n",
    "        \n",
    "        # update rule (≈ 2 lines of code)\n",
    "        ### START CODE HERE ###\n",
    "        w = w - learning_rate * dw\n",
    "        b = b - learning_rate * db\n",
    "        ### END CODE HERE ###\n",
    "        \n",
    "        # Record the costs\n",
    "        if i % 100 == 0:\n",
    "            costs.append(cost)\n",
    "        \n",
    "        # Print the cost every 100 training examples\n",
    "        if print_cost and i % 100 == 0:\n",
    "            print (\"Cost after iteration %i: %f\" %(i, cost))\n",
    "    \n",
    "    params = {\"w\": w,\n",
    "              \"b\": b}\n",
    "    \n",
    "    grads = {\"dw\": dw,\n",
    "             \"db\": db}\n",
    "    \n",
    "    return params, grads, costs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w = [[ 0.1124579 ]\n",
      " [ 0.23106775]]\n",
      "b = 1.55930492484\n",
      "dw = [[ 0.90158428]\n",
      " [ 1.76250842]]\n",
      "db = 0.430462071679\n",
      "[6.0000647731922054]\n"
     ]
    }
   ],
   "source": [
    "params, grads, costs = optimize(w, b, X, Y, num_iterations= 100, learning_rate = 0.009, print_cost = False)\n",
    "\n",
    "print (\"w = \" + str(params[\"w\"]))\n",
    "print (\"b = \" + str(params[\"b\"]))\n",
    "print (\"dw = \" + str(grads[\"dw\"]))\n",
    "print (\"db = \" + str(grads[\"db\"]))\n",
    "print(costs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table style=\"width:40%\">\n",
    "    <tr>\n",
    "       <td> **w** </td>\n",
    "       <td>[[ 0.1124579 ]\n",
    " [ 0.23106775]] </td>\n",
    "    </tr>\n",
    "    \n",
    "    <tr>\n",
    "       <td> **b** </td>\n",
    "       <td> 1.55930492484 </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "       <td> **dw** </td>\n",
    "       <td> [[ 0.90158428]\n",
    " [ 1.76250842]] </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "       <td> **db** </td>\n",
    "       <td> 0.430462071679 </td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** 前面的函数将输出学习到的w和b。我们可以使用训练好的w和b来预测数据集X的标签。预测的步骤有两步：\n",
    "\n",
    "1. Calculate $\\hat{Y} = A = \\sigma(w^T X + b)$\n",
    "\n",
    "2. Convert the entries of a into 0 (if activation <= 0.5) or 1 (if activation > 0.5), stores the predictions in a vector `Y_prediction`. If you wish, you can use an `if`/`else` statement in a `for` loop (though there is also a way to vectorize this). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: predict\n",
    "\n",
    "def predict(w, b, X):\n",
    "    '''\n",
    "    Predict whether the label is 0 or 1 using learned logistic regression parameters (w, b)\n",
    "    \n",
    "    Arguments:\n",
    "    w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n",
    "    b -- bias, a scalar\n",
    "    X -- data of size (num_px * num_px * 3, number of examples)\n",
    "    \n",
    "    Returns:\n",
    "    Y_prediction -- a numpy array (vector) containing all predictions (0/1) for the examples in X\n",
    "    '''\n",
    "    \n",
    "    m = X.shape[1]\n",
    "    Y_prediction = np.zeros((1,m))\n",
    "    w = w.reshape(X.shape[0], 1)\n",
    "    \n",
    "    # Compute vector \"A\" predicting the probabilities of a cat being present in the picture\n",
    "    ### START CODE HERE ### (≈ 1 line of code)\n",
    "    A = sigmoid(np.dot(w.T, X) + b)\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    for i in range(A.shape[1]):\n",
    "        \n",
    "        # Convert probabilities A[0,i] to actual predictions p[0,i]\n",
    "        ### START CODE HERE ### (≈ 4 lines of code)\n",
    "        if A[0, i] <= 0.5:\n",
    "            Y_prediction[0, i] = 0\n",
    "        else:\n",
    "            Y_prediction[0, i] = 1\n",
    "        ### END CODE HERE ###\n",
    "    \n",
    "    assert(Y_prediction.shape == (1, m))\n",
    "    \n",
    "    return Y_prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "predictions = [[ 1.  1.]]\n"
     ]
    }
   ],
   "source": [
    "print (\"predictions = \" + str(predict(w, b, X)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table style=\"width:30%\">\n",
    "    <tr>\n",
    "         <td>\n",
    "             **predictions**\n",
    "         </td>\n",
    "          <td>\n",
    "            [[ 1.  1.]]\n",
    "         </td>  \n",
    "   </tr>\n",
    "\n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<font color='blue'>\n",
    "**What to remember:**\n",
    "你已经实现了几个功能：\n",
    "- Initialize (w,b)\n",
    "- Optimize the loss iteratively to learn parameters (w,b):\n",
    "    - computing the cost and its gradient \n",
    "    - updating the parameters using gradient descent\n",
    "- Use the learned (w,b) to predict the labels for a given set of examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5 - Merge all functions into a model ##\n",
    "\n",
    "现在，您将看到整个模型是如何构建的，将所有构建模块（前面部分中实现的功能）以正确的顺序放在一起。\n",
    "\n",
    "**练习：**实现模型功能。使用以下表示法：\n",
    "    - Y_prediction for your predictions on the test set\n",
    "    - Y_prediction_train for your predictions on the train set\n",
    "    - w, costs, grads for the outputs of optimize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: model\n",
    "\n",
    "def model(X_train, Y_train, X_test, Y_test, num_iterations = 2000, learning_rate = 0.5, print_cost = False):\n",
    "    \"\"\"\n",
    "    Builds the logistic regression model by calling the function you've implemented previously\n",
    "    \n",
    "    Arguments:\n",
    "    X_train -- training set represented by a numpy array of shape (num_px * num_px * 3, m_train)\n",
    "    Y_train -- training labels represented by a numpy array (vector) of shape (1, m_train)\n",
    "    X_test -- test set represented by a numpy array of shape (num_px * num_px * 3, m_test)\n",
    "    Y_test -- test labels represented by a numpy array (vector) of shape (1, m_test)\n",
    "    num_iterations -- hyperparameter representing the number of iterations to optimize the parameters\n",
    "    learning_rate -- hyperparameter representing the learning rate used in the update rule of optimize()\n",
    "    print_cost -- Set to true to print the cost every 100 iterations\n",
    "    \n",
    "    Returns:\n",
    "    d -- dictionary containing information about the model.\n",
    "    \"\"\"\n",
    "    \n",
    "    ### START CODE HERE ###\n",
    "    \n",
    "    # initialize parameters with zeros (≈ 1 line of code)\n",
    "    w, b = initialize_with_zeros(X_train.shape[0])\n",
    "\n",
    "    # Gradient descent (≈ 1 line of code)\n",
    "    parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost)\n",
    "    \n",
    "    # Retrieve parameters w and b from dictionary \"parameters\"\n",
    "    w = parameters[\"w\"]\n",
    "    b = parameters[\"b\"]\n",
    "    \n",
    "    # Predict test/train set examples (≈ 2 lines of code)\n",
    "    Y_prediction_test = predict(w, b, X_test)\n",
    "    Y_prediction_train = predict(w, b, X_train)\n",
    "\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    # Print train/test Errors\n",
    "    print(\"train accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))\n",
    "    print(\"test accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))\n",
    "\n",
    "    \n",
    "    d = {\"costs\": costs,\n",
    "         \"Y_prediction_test\": Y_prediction_test, \n",
    "         \"Y_prediction_train\" : Y_prediction_train, \n",
    "         \"w\" : w, \n",
    "         \"b\" : b,\n",
    "         \"learning_rate\" : learning_rate,\n",
    "         \"num_iterations\": num_iterations}\n",
    "    \n",
    "    return d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the following cell to train your model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after iteration 0: 0.693147\n",
      "Cost after iteration 100: 0.584508\n",
      "Cost after iteration 200: 0.466949\n",
      "Cost after iteration 300: 0.376007\n",
      "Cost after iteration 400: 0.331463\n",
      "Cost after iteration 500: 0.303273\n",
      "Cost after iteration 600: 0.279880\n",
      "Cost after iteration 700: 0.260042\n",
      "Cost after iteration 800: 0.242941\n",
      "Cost after iteration 900: 0.228004\n",
      "Cost after iteration 1000: 0.214820\n",
      "Cost after iteration 1100: 0.203078\n",
      "Cost after iteration 1200: 0.192544\n",
      "Cost after iteration 1300: 0.183033\n",
      "Cost after iteration 1400: 0.174399\n",
      "Cost after iteration 1500: 0.166521\n",
      "Cost after iteration 1600: 0.159305\n",
      "Cost after iteration 1700: 0.152667\n",
      "Cost after iteration 1800: 0.146542\n",
      "Cost after iteration 1900: 0.140872\n",
      "train accuracy: 99.04306220095694 %\n",
      "test accuracy: 70.0 %\n"
     ]
    }
   ],
   "source": [
    "d = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 2000, learning_rate = 0.005, print_cost = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table style=\"width:40%\"> \n",
    "    \n",
    "    <tr>\n",
    "        <td> **Train Accuracy**  </td> \n",
    "        <td> 99.04306220095694 % </td>\n",
    "    </tr>\n",
    "\n",
    "    <tr>\n",
    "        <td>**Test Accuracy** </td> \n",
    "        <td> 70.0 % </td>\n",
    "    </tr>\n",
    "</table> \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Comment**: 训练的准确性接近100％。This is a good sanity check: 您的模型正在运行，并且具有足够的能力来拟合训练数据。测试错误是68％。考虑到我们使用的小数据集，逻辑回归是一个线性分类器，对于这个简单的模型这个结果实际上并不差。不用担心，下周会建立一个更好的分类器！\n",
    "\n",
    "另外，您会发现模型明显过拟合。稍后你将学习如何防止过拟合，例如通过正则化。使用下面的代码（更改index变量），您可以查看测试集的图片预测。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = 1, you predicted that it is a \"cat\" picture.\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP4AAAD8CAYAAABXXhlaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nOxx9CN/4Dkcf4v8DJDXNH7zGKX4AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x240ed361c88>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Example of a picture that was wrongly classified.\n",
    "index = 1\n",
    "plt.imshow(test_set_x[:,index].reshape((num_px, num_px, 3)))\n",
    "print (\"y = \" + str(test_set_y[0,index]) + \", you predicted that it is a \\\"\" + classes[int(d[\"Y_prediction_test\"][0,index])].decode(\"utf-8\") +  \"\\\" picture.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also plot the cost function and the gradients."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x240ed248128>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot learning curve (with costs)\n",
    "costs = np.squeeze(d['costs'])\n",
    "plt.plot(costs)\n",
    "plt.ylabel('cost')\n",
    "plt.xlabel('iterations (per hundreds)')\n",
    "plt.title(\"Learning rate =\" + str(d[\"learning_rate\"]))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Interpretation**:\n",
    "You can see the cost decreasing. It shows that the parameters are being learned. However, you see that you could train the model even more on the training set. Try to increase the number of iterations in the cell above and rerun the cells. You might see that the training set accuracy goes up, but the test set accuracy goes down. This is called overfitting. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6 - Further analysis (optional/ungraded exercise) ##\n",
    "\n",
    "恭喜你构建了你的第一个图像分类模型。现在让我们来进一步分析，研究学习率$\\alpha$的可能性选择。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Choice of learning rate ####\n",
    "**Reminder**：为了使梯度下降起作用，您必须明智地选择学习速度。学习率 α 决定了我们更新参数的速度。如果学习率太高，我们可能会“超过”最优值。同样，如果它太小，我们将需要太多迭代来收敛到最佳值。这就是为什么使用良好的学习速度至关​​重要。\n",
    "\n",
    "让我们来比较一下用了不同学习率的模型的学习曲线。运行下面的单元格。大概需要1分钟。随意尝试不同的值，看看会发生什么。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "learning rate is: 0.01\n",
      "train accuracy: 99.52153110047847 %\n",
      "test accuracy: 68.0 %\n",
      "\n",
      "-------------------------------------------------------\n",
      "\n",
      "learning rate is: 0.001\n",
      "train accuracy: 88.99521531100478 %\n",
      "test accuracy: 64.0 %\n",
      "\n",
      "-------------------------------------------------------\n",
      "\n",
      "learning rate is: 0.0001\n",
      "train accuracy: 68.42105263157895 %\n",
      "test accuracy: 36.0 %\n",
      "\n",
      "-------------------------------------------------------\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEKCAYAAAD9xUlFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nB1rXEmV9gVKsAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x240ee582e10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rates = [0.01, 0.001, 0.0001]\n",
    "models = {}\n",
    "for i in learning_rates:\n",
    "    print (\"learning rate is: \" + str(i))\n",
    "    models[str(i)] = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 1500, learning_rate = i, print_cost = False)\n",
    "    print ('\\n' + \"-------------------------------------------------------\" + '\\n')\n",
    "\n",
    "for i in learning_rates:\n",
    "    plt.plot(np.squeeze(models[str(i)][\"costs\"]), label= str(models[str(i)][\"learning_rate\"]))\n",
    "\n",
    "plt.ylabel('cost')\n",
    "plt.xlabel('iterations')\n",
    "\n",
    "legend = plt.legend(loc='upper center', shadow=True)\n",
    "frame = legend.get_frame()\n",
    "frame.set_facecolor('0.90')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**解读：**\n",
    "- 不同的学习率绘制出了不同的成本函数，并给出了不同的预测结果。\n",
    "- 如果学习率太大（0.01），成本可能会上下波动。It may even diverge ((though in this example, using 0.01 still eventually ends up at a good value for the cost). \n",
    "- 成本较低并不意味着模型更好。你必须检查是否过拟合。过拟合的特征是训练的错误率远低于测试的错误率。\n",
    "- 在深度学习中，我们通常建议您：\n",
    "    - 选择更好地能最小化成本函数的学习率。\n",
    "    - 如果您的模型过拟合，请使用其他技术来减少过拟合。（我们将在稍后的视频中讨论这个问题。）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 7 - 用自己的图片来测试 (optional/ungraded exercise) ##\n",
    "\n",
    "祝贺您完成这项任务。您可以使用自己的图片并查看模型的输出. To do that:\n",
    "    1. Click on \"File\" in the upper bar of this notebook, then click \"Open\" to go on your Coursera Hub.\n",
    "    2. Add your image to this Jupyter Notebook's directory, in the \"images\" folder\n",
    "    3. Change your image's name in the following code\n",
    "    4. Run the code and check if the algorithm is right (1 = cat, 0 = non-cat)!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "## START CODE HERE ## (PUT YOUR IMAGE NAME) \n",
    "my_image = \"cat_in_iran.jpg\"   # change this to the name of your image file \n",
    "## END CODE HERE ##\n",
    "\n",
    "# We preprocess the image to fit your algorithm.\n",
    "fname = \"images/\" + my_image\n",
    "image = np.array(ndimage.imread(fname, flatten=False))\n",
    "my_image = scipy.misc.imresize(image, size=(num_px,num_px)).reshape((1, num_px*num_px*3)).T\n",
    "my_predicted_image = predict(d[\"w\"], d[\"b\"], my_image)\n",
    "\n",
    "plt.imshow(image)\n",
    "print(\"y = \" + str(np.squeeze(my_predicted_image)) + \", your algorithm predicts a \\\"\" + classes[int(np.squeeze(my_predicted_image)),].decode(\"utf-8\") +  \"\\\" picture.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='blue'>\n",
    "**这个作业要记住的是：**\n",
    "- 数据的预处理集非常重要。\n",
    "- 你分别实现了下面的每个函数：initialize（），propagate（），optimize（）。然后你建立了一个模型。\n",
    "- 调整学习率（这是“超参数”的一个例子）会对算法产生很大的影响。在本课程后面你会看到更多的例子！"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后，如果你愿意，我们希望你尝试些不同的东西。\n",
    "    - Play with the learning rate and the number of iterations\n",
    "    - Try different initialization methods and compare the results\n",
    "    - Test other preprocessings (center the data, or divide each row by its standard deviation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bibliography(参考书目):\n",
    "- http://www.wildml.com/2015/09/implementing-a-neural-network-from-scratch/\n",
    "- https://stats.stackexchange.com/questions/211436/why-do-we-normalize-images-by-subtracting-the-datasets-image-mean-and-not-the-c"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "coursera": {
   "course_slug": "neural-networks-deep-learning",
   "graded_item_id": "XaIWT",
   "launcher_item_id": "zAgPl"
  },
  "kernelspec": {
   "display_name": "Python [default]",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
